package com.woniu.serviceprice.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.woniu.internalcommon.constant.CommonStatusEnum;
import com.woniu.internalcommon.dto.PriceRule;
import com.woniu.internalcommon.dto.ResponseResult;
import com.woniu.serviceprice.mapper.PriceRuleMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @Description: 
 * @return: 
 * @Author:  zcnovice
 * @date:  2025/7/10 上午11:20
 */
@Service
public class PriceRuleService {

    @Autowired
    PriceRuleMapper priceRuleMapper;

    //程序会自动生成fareType和fareVersion
    /* 流程：管理员输入城市代码，车辆类型，起步价等信息   -->   后端生成运价类型编码    -->    查找同一城市同一车型的
    所有计价规则，并按版本号降序排列    -->    如果已存在该城市/车型的计价规则，返回"规则已存在"错误(版本是用于修改的计价规则的) */
    public ResponseResult add(PriceRule priceRule){

        // 拼接fareType
        /* 获取城市代码 */
        String cityCode = priceRule.getCityCode();
        /* 车辆类型 */
        String vehicleType = priceRule.getVehicleType();
        /* 获取城市代码 + $ + 车辆类型 = 运价类型编码 */
        String fareType = cityCode + "$" + vehicleType;
        priceRule.setFareType(fareType);

        // 添加版本号
        // 问题1：增加了版本号，前面的两个字段无法唯一确定一条记录，问题2：找最大的版本号，需要排序

        /* Mybatis条件构造器 */
        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("city_code",cityCode);
        queryWrapper.eq("vehicle_type",vehicleType);
        /* 按照fare_version降序排列 */
        queryWrapper.orderByDesc("fare_version");

        /* 查询出来（会有同一城市同一车型的不同的计价版本） */
        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);
        /* 设置版本号（fareVersion） */
        Integer fareVersion = 0;
        /* 查询结果不为空 说明该城市/车型组合已有计价规则
        返回失败响应，防止重复创建相同城市/车型的规则*/
        if (priceRules.size()>0){
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EXISTS.getCode(),CommonStatusEnum.PRICE_RULE_EXISTS.getValue());
        }
        priceRule.setFareVersion(++fareVersion);


        priceRuleMapper.insert(priceRule);
        return ResponseResult.success();
    }



    public ResponseResult edit(PriceRule priceRule){
        // 拼接fareType
        /* 与添加一样的拼接 */
        String cityCode = priceRule.getCityCode();
        String vehicleType = priceRule.getVehicleType();
        String fareType = cityCode + "$" + vehicleType;
        priceRule.setFareType(fareType);

        // 添加版本号
        // 问题1：增加了版本号，前面的两个字段无法唯一确定一条记录，问题2：找最大的版本号，需要排序

        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("city_code",cityCode);
        queryWrapper.eq("vehicle_type",vehicleType);
        queryWrapper.orderByDesc("fare_version");

        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);
        Integer fareVersion = 0;


        /* 下面开始不一样 */
        if (priceRules.size()>0){
            /* 获取版本最新的这条数据 */
            PriceRule lasterPriceRule = priceRules.get(0);

            /* 获取版本最新的详细数据 */
            Double unitPricePerMile = lasterPriceRule.getUnitPricePerMile();
            Double unitPricePerMinute = lasterPriceRule.getUnitPricePerMinute();
            Double startFare = lasterPriceRule.getStartFare();
            Integer startMile = lasterPriceRule.getStartMile();


            /* 判断  数据库里面版本最新的数据       与         传入的数据是否相同  */
            if (unitPricePerMile.doubleValue() == priceRule.getUnitPricePerMile().doubleValue()
            && unitPricePerMinute.doubleValue() == priceRule.getUnitPricePerMinute().doubleValue()
            && startFare.doubleValue() == priceRule.getStartFare().doubleValue()
            && startMile.intValue() == priceRule.getStartMile().intValue()){

                /* 如果相等说明没有修改 */
                return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_NOT_EDIT.getCode(),CommonStatusEnum.PRICE_RULE_NOT_EDIT.getValue());
            }


            //  设置版本号
            /* 版本号等于数据库里面最新的版本号 */
            fareVersion = lasterPriceRule.getFareVersion();
        }
        //与数据库里面的最新数据不相同，版本加一后存入数据库（当新的计价规则）
        /* 把版本号+1 */
        priceRule.setFareVersion(++fareVersion);
        priceRule.setId(generateRandomId());

        priceRuleMapper.insert(priceRule);
        return ResponseResult.success();
    }


    /* 传入一个String类型的版本编号，根据这个版本编号fare_type(String)  查询fare_version(int)最高的版本 */
    public ResponseResult<PriceRule> getNewestVersion(String fareType){
        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("fare_type",fareType);

        /* int编号降序排列 */
        queryWrapper.orderByDesc("fare_version");

        /* 查询出所有数据 */
        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);

        /* 判断数据库里面是否有数据 */
        if (priceRules.size() > 0){
            /* 有数据就返回第一条数据回去 */
            return ResponseResult.success(priceRules.get(0));
        }else {
            /* 没有数据就返回 */
            //   PRICE_RULE_EMPTY(1300,"计价规则不存在")
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EMPTY.getCode(),CommonStatusEnum.PRICE_RULE_EMPTY.getValue());
        }


    }


    /* 判断规则是不是最新的 */
    public ResponseResult<Boolean> isNew(String fareType, int fareVersion){
        /* getNewestVersion获取最新的版本 */
        ResponseResult<PriceRule> newestVersionPriceRule = getNewestVersion(fareType);

        /* 判断是否有这条数据   --   CommonStatusEnum.PRICE_RULE_EMPTY.getCode() */
        if (newestVersionPriceRule.getCode() == CommonStatusEnum.PRICE_RULE_EMPTY.getCode()){
            /* 没有 */
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EMPTY.getCode(),CommonStatusEnum.PRICE_RULE_EMPTY.getValue());
//            return ResponseResult.success(false);
        }

        /* 有数据，获取数据（版本号） */
        PriceRule priceRule = newestVersionPriceRule.getData();
        Integer fareVersionDB = priceRule.getFareVersion();

        /* 判断数据库里面的版本是否比传入的版本高 */
        if (fareVersionDB > fareVersion){
            return ResponseResult.success(false);
        }else {
            return ResponseResult.success(true);
        }

    }

    /* 判断改城市与车型计价规则是否存在 */
    public ResponseResult<Boolean> ifExists_old(PriceRule priceRule){
        /* 获取传过来的城市与车型数据 */
        String cityCode = priceRule.getCityCode();
        String vehicleType = priceRule.getVehicleType();

        /* 查询数据库里面有没有对应的数据 */
        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("city_code",cityCode);
        queryWrapper.eq("vehicle_type",vehicleType);
        queryWrapper.orderByDesc("fare_version");

        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);


        /* priceRules.size() > 0   说明有返回true */
        if (priceRules.size() > 0){
            return ResponseResult.success(true);
        }else {
            return ResponseResult.success(false);
        }
    }



    /* 判断改城市与车型计价规则是否存在 */
    public ResponseResult<Boolean> ifExists(String cityCode,String vehicleType){
        /* 查询数据库里面有没有对应的数据 */
        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("city_code",cityCode);
        queryWrapper.eq("vehicle_type",vehicleType);
        queryWrapper.orderByDesc("fare_version");

        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);


        /* priceRules.size() > 0   说明有返回true */
        if (priceRules.size() > 0){
            return ResponseResult.success(true);
        }else {
            return ResponseResult.success(false);
        }
    }




    /*查询所有的计价规则*/
    public ResponseResult<List<PriceRule>> getAllPriceRules(){
        /* 构建条件选择器 */
        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("fare_version").orderByAsc("city_code").orderByAsc("vehicle_type");
        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);
        return ResponseResult.success(priceRules);
    }

    /* 条件查询计价规则 */
    public ResponseResult<Page<PriceRule>> getPriceRulesByConditions(Integer current,Integer size,PriceRule priceRule){
        /* 分页 */
        Page<PriceRule> priceRulePage = new Page<>(current,size);


        QueryWrapper<PriceRule> queryWrapper = new QueryWrapper<>();
        /* 动态条件查询 */
        if (priceRule.getCityCode() != null && priceRule.getCityCode()!= "") {
            queryWrapper.eq("city_code", priceRule.getCityCode());
        }
        if(priceRule.getVehicleType() !=null && priceRule.getVehicleType() != ""){
            queryWrapper.eq("vehicle_type",priceRule.getVehicleType());
        }
        if(priceRule.getFareType()!=null && priceRule.getFareType()!= ""){
            queryWrapper.eq("fare_type",priceRule.getFareType());
        }
        if(priceRule.getFareVersion()!=null && priceRule.getFareVersion() != 0){
            queryWrapper.eq("fare_version",priceRule.getFareVersion());
        }

        queryWrapper.orderByDesc("fare_version");

//        List<PriceRule> priceRules = priceRuleMapper.selectList(queryWrapper);

        Page<PriceRule> priceRulePage1 = priceRuleMapper.selectPage(priceRulePage, queryWrapper);


        return ResponseResult.success(priceRulePage1);
    }



    public static Long generateRandomId() {
        long min = 10_000_000L;
        long max = 2_047_483_647L;

        return ThreadLocalRandom.current().nextLong(min, max + 1);
    }

    /* 删除计价规则 */
    public ResponseResult delete(Long id) {
        // 检查ID是否存在
        if (id == null || id <= 0) {
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EMPTY.getCode(), "ID不能为空");
        }

        // 检查记录是否存在
        PriceRule priceRule = priceRuleMapper.selectById(id);
        if (priceRule == null) {
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EMPTY.getCode(), "计价规则不存在");
        }

        // 执行删除
        int result = priceRuleMapper.deleteById(id);
        if (result > 0) {
            return ResponseResult.success();
        } else {
            return ResponseResult.fail(CommonStatusEnum.PRICE_RULE_EMPTY.getCode(), "删除失败");
        }
    }

}
